声明 模块 "util" {

    //@@{ 检查选项_:InspectOptions }
    接口 检查选项_ 扩展 NodeJS.检查选项_ { }

    //@@{ 格式化:format }
    函数 格式化(格式化: 任意, ...参数: 任意[]): 文字;

    //@@{ 格式化包括选项:formatWithOptions, 检查选项_:InspectOptions }
    函数 格式化包括选项(检查选项: 检查选项_, 格式化: 文字, ...参数: 任意[]): 文字;
    /** @deprecated since v0.11.3 - use `console.error()` instead. */

    //@@{ 调试程序:debug }
    函数 调试程序(文字: 文字): 无值;
    /** @deprecated since v0.11.3 - use `console.error()` instead. */

    //@@{ 错误:error }
    函数 错误(...参数: 任意[]): 无值;
    /** @deprecated since v0.11.3 - use `console.log()` instead. */

    //@@{ 输出行:puts }
    函数 输出行(...参数: 任意[]): 无值;
    /** @deprecated since v0.11.3 - use `console.log()` instead. */

    //@@{ 打印:print }
    函数 打印(...参数: 任意[]): 无值;
    /** @deprecated since v0.11.3 - use a third party module instead. */

    //@@{ 日志:log }
    函数 日志(文字: 文字): 无值;

    //@@{ 检查:inspect }
    函数 检查(对象: 任意, 显示隐藏?: 真假, 深度?: 数字 | 空值, 颜色?: 真假): 文字;

    //@@{ 检查:inspect, 检查选项_:InspectOptions }
    函数 检查(对象: 任意, 选项组: 检查选项_): 文字;

    //@@{ 检查:inspect }
    名域 检查 {

        //@@{ 颜色集:colors }
        变量 颜色集: {
            [颜色: 文字]: [数字, 数字] | 未定
        };

        //@@{ 样式组:styles }
        变量 样式组: {
            [样式: 文字]: 文字 | 未定
        };

        //@@{ 默认选项:defaultOptions, 检查选项_:InspectOptions }
        变量 默认选项: 检查选项_;
        /**
         * Allows changing inspect settings from the repl.
         */

        //@@{ repl默认值:replDefaults, 检查选项_:InspectOptions }
        变量 repl默认值: 检查选项_;
    }
    /** @deprecated since v4.0.0 - use `Array.isArray()` instead. */

    //@@{ 是数组:isArray }
    函数 是数组(对象: 任意): 对象 作为 任意[];
    /** @deprecated since v4.0.0 - use `util.types.isRegExp()` instead. */

    //@@{ 是正则表达式:isRegExp, 正则_:RegExp }
    函数 是正则表达式(对象: 任意): 对象 作为 正则_;
    /** @deprecated since v4.0.0 - use `util.types.isDate()` instead. */

    //@@{ 是日期:isDate, 日期_:Date }
    函数 是日期(对象: 任意): 对象 作为 日期_;
    /** @deprecated since v4.0.0 - use `util.types.isNativeError()` instead. */

    //@@{ 是错误:isError, 错误_:Error }
    函数 是错误(对象: 任意): 对象 作为 错误_;

    //@@{ 继承了:inherits }
    函数 继承了(构造: 任意, 父构造函数: 任意): 无值;

    //@@{ 调试日志:debuglog }
    函数 调试日志(key: 文字): (消息: 文字, ...参数: 任意[]) => 无值;
    /** @deprecated since v4.0.0 - use `typeof value === 'boolean'` instead. */

    //@@{ 是真假:isBoolean }
    函数 是真假(对象: 任意): 对象 作为 真假;
    /** @deprecated since v4.0.0 - use `Buffer.isBuffer()` instead. */

    //@@{ 是缓冲区:isBuffer, 缓冲区_:Buffer }
    函数 是缓冲区(对象: 任意): 对象 作为 缓冲区_;
    /** @deprecated since v4.0.0 - use `typeof value === 'function'` instead. */

    //@@{ 是函数:isFunction }
    函数 是函数(对象: 任意): 真假;
    /** @deprecated since v4.0.0 - use `value === null` instead. */

    //@@{ 是空值:isNull }
    函数 是空值(对象: 任意): 对象 作为 空值;
    /** @deprecated since v4.0.0 - use `value === null || value === undefined` instead. */

    //@@{ 是空值或未定:isNullOrUndefined }
    函数 是空值或未定(对象: 任意): 对象 作为 空值 | 未定;
    /** @deprecated since v4.0.0 - use `typeof value === 'number'` instead. */

    //@@{ 是数字:isNumber }
    函数 是数字(对象: 任意): 对象 作为 数字;
    /** @deprecated since v4.0.0 - use `value !== null && typeof value === 'object'` instead. */

    //@@{ 是实例:isObject }
    函数 是实例(对象: 任意): 真假;
    /** @deprecated since v4.0.0 - use `(typeof value !== 'object' && typeof value !== 'function') || value === null` instead. */

    //@@{ 是原始的:isPrimitive }
    函数 是原始的(对象: 任意): 真假;
    /** @deprecated since v4.0.0 - use `typeof value === 'string'` instead. */

    //@@{ 是文字:isString }
    函数 是文字(对象: 任意): 对象 作为 文字;
    /** @deprecated since v4.0.0 - use `typeof value === 'symbol'` instead. */

    //@@{ 是符号:isSymbol }
    函数 是符号(对象: 任意): 对象 作为 符号;
    /** @deprecated since v4.0.0 - use `value === undefined` instead. */

    //@@{ 是未定:isUndefined }
    函数 是未定(对象: 任意): 对象 作为 未定;

    //@@{ 标记为废弃:deprecate, 函数_:Function }
    函数 标记为废弃<T 扩展 函数_>(函: T, 消息: 文字): T;

    //@@{ 是深度严格相等的:isDeepStrictEqual }
    函数 是深度严格相等的(val1: 任意, val2: 任意): 真假;

    //@@{ 自定义预设_:CustomPromisify, 函数_:Function }
    接口 自定义预设_<T自定义_ 扩展 函数_> 扩展 函数_ {

        //@@{ __转为预设__:__promisify__, T自定义_:TCustom }
        __转为预设__: T自定义_;
    }

    //@@{ 转为回调:callbackify, 预设_:Promise, 错误异常_:ErrnoException }
    函数 转为回调(运行函数: () => 预设_<无值>): (回调: (错: NodeJS.错误异常_) => 无值) => 无值;

    //@@{ 转为回调:callbackify, 预设_:Promise, T结果_:TResult, 错误异常_:ErrnoException }
    函数 转为回调<T结果_>(运行函数: () => 预设_<T结果_>): (回调: (错: NodeJS.错误异常_, 结果: T结果_) => 无值) => 无值;

    //@@{ 转为回调:callbackify, 预设_:Promise, 错误异常_:ErrnoException }
    函数 转为回调<T1>(运行函数: (参数1: T1) => 预设_<无值>): (参数1: T1, 回调: (错: NodeJS.错误异常_) => 无值) => 无值;

    //@@{ 转为回调:callbackify, 预设_:Promise, T结果_:TResult, 错误异常_:ErrnoException }
    函数 转为回调<T1, T结果_>(运行函数: (参数1: T1) => 预设_<T结果_>): (参数1: T1, 回调: (错: NodeJS.错误异常_, 结果: T结果_) => 无值) => 无值;

    //@@{ 转为回调:callbackify, 预设_:Promise, 错误异常_:ErrnoException }
    函数 转为回调<T1, T2>(运行函数: (参数1: T1, 参数2: T2) => 预设_<无值>): (参数1: T1, 参数2: T2, 回调: (错: NodeJS.错误异常_) => 无值) => 无值;

    //@@{ 转为回调:callbackify, 预设_:Promise, T结果_:TResult, 错误异常_:ErrnoException }
    函数 转为回调<T1, T2, T结果_>(运行函数: (参数1: T1, 参数2: T2) => 预设_<T结果_>): (参数1: T1, 参数2: T2, 回调: (错: NodeJS.错误异常_ | 空值, 结果: T结果_) => 无值) => 无值;

    //@@{ 转为回调:callbackify, 预设_:Promise, 错误异常_:ErrnoException }
    函数 转为回调<T1, T2, T3>(运行函数: (参数1: T1, 参数2: T2, 参数3: T3) => 预设_<无值>): (参数1: T1, 参数2: T2, 参数3: T3, 回调: (错: NodeJS.错误异常_) => 无值) => 无值;

    //@@{ 转为回调:callbackify }
    函数 转为回调<T1, T2, T3, T结果_>(

        //@@{ 预设_:Promise, T结果_:TResult, 错误异常_:ErrnoException }
        运行函数: (参数1: T1, 参数2: T2, 参数3: T3) => 预设_<T结果_>): (参数1: T1, 参数2: T2, 参数3: T3, 回调: (错: NodeJS.错误异常_ | 空值, 结果: T结果_) => 无值) => 无值;

    //@@{ 转为回调:callbackify }
    函数 转为回调<T1, T2, T3, T4>(

        //@@{ 预设_:Promise, 错误异常_:ErrnoException }
        运行函数: (参数1: T1, 参数2: T2, 参数3: T3, 参数4: T4) => 预设_<无值>): (参数1: T1, 参数2: T2, 参数3: T3, 参数4: T4, 回调: (错: NodeJS.错误异常_) => 无值) => 无值;

    //@@{ 转为回调:callbackify }
    函数 转为回调<T1, T2, T3, T4, T结果_>(

        //@@{ 预设_:Promise, T结果_:TResult, 错误异常_:ErrnoException }
        运行函数: (参数1: T1, 参数2: T2, 参数3: T3, 参数4: T4) => 预设_<T结果_>): (参数1: T1, 参数2: T2, 参数3: T3, 参数4: T4, 回调: (错: NodeJS.错误异常_ | 空值, 结果: T结果_) => 无值) => 无值;

    //@@{ 转为回调:callbackify }
    函数 转为回调<T1, T2, T3, T4, T5>(

        //@@{ 预设_:Promise, 错误异常_:ErrnoException }
        运行函数: (参数1: T1, 参数2: T2, 参数3: T3, 参数4: T4, 参数5: T5) => 预设_<无值>): (参数1: T1, 参数2: T2, 参数3: T3, 参数4: T4, 参数5: T5, 回调: (错: NodeJS.错误异常_) => 无值) => 无值;

    //@@{ 转为回调:callbackify }
    函数 转为回调<T1, T2, T3, T4, T5, T结果_>(

        //@@{ 预设_:Promise, T结果_:TResult }
        运行函数: (参数1: T1, 参数2: T2, 参数3: T3, 参数4: T4, 参数5: T5) => 预设_<T结果_>,

    //@@{ 错误异常_:ErrnoException, T结果_:TResult }
    ): (参数1: T1, 参数2: T2, 参数3: T3, 参数4: T4, 参数5: T5, 回调: (错: NodeJS.错误异常_ | 空值, 结果: T结果_) => 无值) => 无值;

    //@@{ 转为回调:callbackify }
    函数 转为回调<T1, T2, T3, T4, T5, T6>(

        //@@{ 预设_:Promise }
        运行函数: (参数1: T1, 参数2: T2, 参数3: T3, 参数4: T4, 参数5: T5, 参数6: T6) => 预设_<无值>,

    //@@{ 错误异常_:ErrnoException }
    ): (参数1: T1, 参数2: T2, 参数3: T3, 参数4: T4, 参数5: T5, 参数6: T6, 回调: (错: NodeJS.错误异常_) => 无值) => 无值;

    //@@{ 转为回调:callbackify }
    函数 转为回调<T1, T2, T3, T4, T5, T6, T结果_>(

        //@@{ 预设_:Promise, T结果_:TResult }
        运行函数: (参数1: T1, 参数2: T2, 参数3: T3, 参数4: T4, 参数5: T5, 参数6: T6) => 预设_<T结果_>

    //@@{ 错误异常_:ErrnoException, T结果_:TResult }
    ): (参数1: T1, 参数2: T2, 参数3: T3, 参数4: T4, 参数5: T5, 参数6: T6, 回调: (错: NodeJS.错误异常_ | 空值, 结果: T结果_) => 无值) => 无值;

    //@@{ 转为预设:promisify, 函数_:Function, 自定义预设_:CustomPromisify, T自定义_:TCustom }
    函数 转为预设<T自定义_ 扩展 函数_>(函: 自定义预设_<T自定义_>): T自定义_;

    //@@{ 转为预设:promisify, 错误_:Error, T结果_:TResult, 预设_:Promise }
    函数 转为预设<T结果_>(运行函数: (回调: (错: 错误_ | 空值, 结果: T结果_) => 无值) => 无值): () => 预设_<T结果_>;

    //@@{ 转为预设:promisify, 错误_:Error, 预设_:Promise }
    函数 转为预设(运行函数: (回调: (错?: 错误_) => 无值) => 无值): () => 预设_<无值>;

    //@@{ 转为预设:promisify, 错误_:Error, T结果_:TResult, 预设_:Promise }
    函数 转为预设<T1, T结果_>(运行函数: (参数1: T1, 回调: (错: 错误_ | 空值, 结果: T结果_) => 无值) => 无值): (参数1: T1) => 预设_<T结果_>;

    //@@{ 转为预设:promisify, 错误_:Error, 预设_:Promise }
    函数 转为预设<T1>(运行函数: (参数1: T1, 回调: (错?: 错误_) => 无值) => 无值): (参数1: T1) => 预设_<无值>;

    //@@{ 转为预设:promisify, 错误_:Error, T结果_:TResult, 预设_:Promise }
    函数 转为预设<T1, T2, T结果_>(运行函数: (参数1: T1, 参数2: T2, 回调: (错: 错误_ | 空值, 结果: T结果_) => 无值) => 无值): (参数1: T1, 参数2: T2) => 预设_<T结果_>;

    //@@{ 转为预设:promisify, 错误_:Error, 预设_:Promise }
    函数 转为预设<T1, T2>(运行函数: (参数1: T1, 参数2: T2, 回调: (错?: 错误_) => 无值) => 无值): (参数1: T1, 参数2: T2) => 预设_<无值>;

    //@@{ 转为预设:promisify, 错误_:Error, T结果_:TResult, 预设_:Promise }
    函数 转为预设<T1, T2, T3, T结果_>(运行函数: (参数1: T1, 参数2: T2, 参数3: T3, 回调: (错: 错误_ | 空值, 结果: T结果_) => 无值) => 无值): (参数1: T1, 参数2: T2, 参数3: T3) => 预设_<T结果_>;

    //@@{ 转为预设:promisify, 错误_:Error, 预设_:Promise }
    函数 转为预设<T1, T2, T3>(运行函数: (参数1: T1, 参数2: T2, 参数3: T3, 回调: (错?: 错误_) => 无值) => 无值): (参数1: T1, 参数2: T2, 参数3: T3) => 预设_<无值>;

    //@@{ 转为预设:promisify }
    函数 转为预设<T1, T2, T3, T4, T结果_>(

        //@@{ 错误_:Error, T结果_:TResult }
        运行函数: (参数1: T1, 参数2: T2, 参数3: T3, 参数4: T4, 回调: (错: 错误_ | 空值, 结果: T结果_) => 无值) => 无值,

    //@@{ 预设_:Promise, T结果_:TResult }
    ): (参数1: T1, 参数2: T2, 参数3: T3, 参数4: T4) => 预设_<T结果_>;

    //@@{ 转为预设:promisify, 错误_:Error, 预设_:Promise }
    函数 转为预设<T1, T2, T3, T4>(运行函数: (参数1: T1, 参数2: T2, 参数3: T3, 参数4: T4, 回调: (错?: 错误_) => 无值) => 无值): (参数1: T1, 参数2: T2, 参数3: T3, 参数4: T4) => 预设_<无值>;

    //@@{ 转为预设:promisify }
    函数 转为预设<T1, T2, T3, T4, T5, T结果_>(

        //@@{ 错误_:Error, T结果_:TResult }
        运行函数: (参数1: T1, 参数2: T2, 参数3: T3, 参数4: T4, 参数5: T5, 回调: (错: 错误_ | 空值, 结果: T结果_) => 无值) => 无值,

    //@@{ 预设_:Promise, T结果_:TResult }
    ): (参数1: T1, 参数2: T2, 参数3: T3, 参数4: T4, 参数5: T5) => 预设_<T结果_>;

    //@@{ 转为预设:promisify }
    函数 转为预设<T1, T2, T3, T4, T5>(

        //@@{ 错误_:Error }
        运行函数: (参数1: T1, 参数2: T2, 参数3: T3, 参数4: T4, 参数5: T5, 回调: (错?: 错误_) => 无值) => 无值,

    //@@{ 预设_:Promise }
    ): (参数1: T1, 参数2: T2, 参数3: T3, 参数4: T4, 参数5: T5) => 预设_<无值>;

    //@@{ 转为预设:promisify, 函数_:Function }
    函数 转为预设(运行函数: 函数_): 函数_;

    //@@{ 类型组:types }
    名域 类型组 {

        //@@{ 是任何数组缓冲区:isAnyArrayBuffer }
        函数 是任何数组缓冲区(对象: 任意): 真假;

        //@@{ 是参数对象:isArgumentsObject, 增强参数组接口_:IArguments }
        函数 是参数对象(对象: 任意): 对象 作为 增强参数组接口_;

        //@@{ 是数组缓冲区:isArrayBuffer, 数组缓冲区_:ArrayBuffer }
        函数 是数组缓冲区(对象: 任意): 对象 作为 数组缓冲区_;

        //@@{ 是异步函数:isAsyncFunction }
        函数 是异步函数(对象: 任意): 真假;

        //@@{ 是布尔对象:isBooleanObject, 真假_:Boolean }
        函数 是布尔对象(对象: 任意): 对象 作为 真假_;

        //@@{ 是原始装箱:isBoxedPrimitive, 数字_:Number, 真假_:Boolean, 文字_:String, 符号_:Symbol }
        函数 是原始装箱(对象: 任意): 对象 作为 (数字_ | 真假_ | 文字_ | 符号_ /* | Object(BigInt) | Object(Symbol) */);

        //@@{ 是数据视图:isDataView, 数据视图_:DataView }
        函数 是数据视图(对象: 任意): 对象 作为 数据视图_;

        //@@{ 是日期:isDate, 日期_:Date }
        函数 是日期(对象: 任意): 对象 作为 日期_;

        //@@{ 是外部的:isExternal }
        函数 是外部的(对象: 任意): 真假;

        //@@{ 是浮点数组32:isFloat32Array, 浮点数组32_:Float32Array }
        函数 是浮点数组32(对象: 任意): 对象 作为 浮点数组32_;

        //@@{ 是浮点数组64:isFloat64Array, 浮点数组64_:Float64Array }
        函数 是浮点数组64(对象: 任意): 对象 作为 浮点数组64_;

        //@@{ 是引擎函数:isGeneratorFunction }
        函数 是引擎函数(对象: 任意): 真假;

        //@@{ 是引擎对象:isGeneratorObject }
        函数 是引擎对象(对象: 任意): 真假;

        //@@{ 是整数数组8:isInt8Array, 整数数组8_:Int8Array }
        函数 是整数数组8(对象: 任意): 对象 作为 整数数组8_;

        //@@{ 是整数数组16:isInt16Array, 整数数组16_:Int16Array }
        函数 是整数数组16(对象: 任意): 对象 作为 整数数组16_;

        //@@{ 是整数数组32:isInt32Array, 整数数组32_:Int32Array }
        函数 是整数数组32(对象: 任意): 对象 作为 整数数组32_;

        //@@{ 是映射:isMap }
        函数 是映射(对象: 任意): 真假;

        //@@{ 是映射迭代器:isMapIterator }
        函数 是映射迭代器(对象: 任意): 真假;

        //@@{ 是模块名域对象:isModuleNamespaceObject }
        函数 是模块名域对象(值: 任意): 真假;

        //@@{ 是本机错误:isNativeError, 错误_:Error }
        函数 是本机错误(对象: 任意): 对象 作为 错误_;

        //@@{ 是数字对象:isNumberObject, 数字_:Number }
        函数 是数字对象(对象: 任意): 对象 作为 数字_;

        //@@{ 是预设:isPromise }
        函数 是预设(对象: 任意): 真假;

        //@@{ 是代理:isProxy }
        函数 是代理(对象: 任意): 真假;

        //@@{ 是正则表达式:isRegExp, 正则_:RegExp }
        函数 是正则表达式(对象: 任意): 对象 作为 正则_;

        //@@{ 是集合:isSet }
        函数 是集合(对象: 任意): 真假;

        //@@{ 是集合迭代器:isSetIterator }
        函数 是集合迭代器(对象: 任意): 真假;

        //@@{ 是共享数组缓冲区:isSharedArrayBuffer }
        函数 是共享数组缓冲区(对象: 任意): 真假;

        //@@{ 是文字对象:isStringObject }
        函数 是文字对象(对象: 任意): 真假;

        //@@{ 是符号对象:isSymbolObject }
        函数 是符号对象(对象: 任意): 真假;

        //@@{ 是类型数组:isTypedArray, 类型数组_:TypedArray }
        函数 是类型数组(对象: 任意): 对象 作为 NodeJS.类型数组_;

        //@@{ 是正整数数组8:isUint8Array, 正整数数组8_:Uint8Array }
        函数 是正整数数组8(对象: 任意): 对象 作为 正整数数组8_;

        //@@{ 是固定正整数数组8:isUint8ClampedArray, 正整数固定数组8_:Uint8ClampedArray }
        函数 是固定正整数数组8(对象: 任意): 对象 作为 正整数固定数组8_;

        //@@{ 是正整数数组16:isUint16Array, 正整数数组16_:Uint16Array }
        函数 是正整数数组16(对象: 任意): 对象 作为 正整数数组16_;

        //@@{ 是正整数数组32:isUint32Array, 正整数数组32_:Uint32Array }
        函数 是正整数数组32(对象: 任意): 对象 作为 正整数数组32_;

        //@@{ 是弱映射:isWeakMap }
        函数 是弱映射(对象: 任意): 真假;

        //@@{ 是弱集合:isWeakSet }
        函数 是弱集合(对象: 任意): 真假;

        //@@{ 是Web程序集编译模块:isWebAssemblyCompiledModule }
        函数 是Web程序集编译模块(对象: 任意): 真假;
    }

    //@@{ 文本解码器_:TextDecoder }
    类别 文本解码器_ {

        //@@{ 编码:encoding }
        只读 编码: 文字;

        //@@{ 致命的:fatal }
        只读 致命的: 真假;

        //@@{ 忽略BOM:ignoreBOM }
        只读 忽略BOM: 真假;
        构造(
          编码?: 文字,

          //@@{ 致命的:fatal, 忽略BOM:ignoreBOM }
          选项组?: { 致命的?: 真假; 忽略BOM?: 真假 }
        );

        //@@{ 解码:decode }
        解码(

          //@@{ 类型数组_:TypedArray, 数据视图_:DataView, 数组缓冲区_:ArrayBuffer }
          输入?: NodeJS.类型数组_ | 数据视图_ | 数组缓冲区_ | 空值,

          //@@{ 流:stream }
          选项组?: { 流?: 真假 }
        ): 文字;
    }

    //@@{ 文本编码器_:TextEncoder }
    类别 文本编码器_ {

        //@@{ 编码:encoding }
        只读 编码: 文字;

        //@@{ 编码输入:encode, 正整数数组8_:Uint8Array }
        编码输入(输入?: 文字): 正整数数组8_;
    }
}
